package motypes

import (
	"database/sql/driver"
	"encoding/json"
	"fmt"
	"strings"
	"time"
)

const defaultTimeFormat = time.DateTime

type MoTime struct {
	time.Time
}

func NowTime() *MoTime {
	return &MoTime{Time: time.Now()}
}

// 实现 Scanner 接口
func (t *MoTime) Scan(src interface{}) error {
	switch src := src.(type) {
	case time.Time:
		*t = MoTime{Time: src}
		return nil
	case []byte:
		parsedTime, err := time.Parse(defaultTimeFormat, string(src))
		if err != nil {
			return err
		}
		*t = MoTime{Time: parsedTime}
		return nil
	default:
		return fmt.Errorf("unsupported type: %T", src)
	}
}

// 实现 Valuer 接口
func (t MoTime) Value() (driver.Value, error) {
	if t.IsZero() {
		return nil, nil
	}
	return t.Time, nil
}

// 实现 MarshalJSON 方法来自定义 JSON 序列化格式
func (t MoTime) MarshalJSON() ([]byte, error) {
	if t.IsZero() {
		return []byte(`"0001-01-01T00:00:00Z"`), nil // 处理零值的情况
	}
	return []byte(`"` + t.Format(defaultTimeFormat) + `"`), nil
}

// 实现 UnmarshalJSON 方法来自定义 JSON 反序列化格式
func (t *MoTime) UnmarshalJSON(data []byte) error {
	var s string
	if err := json.Unmarshal(data, &s); err != nil {
		return err
	}

	// 解析 JSON 标签中的时间格式
	format := defaultTimeFormat // 默认格式为 RFC3339
	tag := getJSONTag(data)
	if tag != "" {
		format = tag
	}

	parsedTime, err := time.Parse(format, s)
	if err != nil {
		return err
	}
	*t = MoTime{Time: parsedTime}
	return nil
}

// 从 JSON 数据中提取时间格式标签
func getJSONTag(data []byte) string {
	// 解析 JSON 数据
	var jsonData map[string]string
	if err := json.Unmarshal(data, &jsonData); err != nil {
		return ""
	}

	// 获取时间格式标签
	for _, v := range jsonData {
		parts := strings.Split(v, ",")
		for _, part := range parts {
			if strings.HasPrefix(part, "format=") {
				format := strings.TrimPrefix(part, "format=")
				return format
			}
		}
	}
	return ""
}
